home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / DistUpgrade / DistUpgradeViewKDE3.py < prev    next >
Text File  |  2009-11-02  |  29KB  |  714 lines
  1. # DistUpgradeViewKDE.py 
  2. #  
  3. #  Copyright (c) 2007 Canonical Ltd
  4. #  
  5. #  Author: Jonathan Riddell <jriddell@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21. #
  22. # THIS FRONTEND IS DEPRECATED IN FAVOR OF THE KDE4 ONE
  23. #
  24.  
  25. from qt import *
  26. from kdeui import *
  27. from kdecore import *
  28. from kio import KRun
  29. #from dcopext import DCOPClient, DCOPApp # used to quit adept
  30.  
  31. import sys
  32. import logging
  33. import time
  34. import subprocess
  35. import traceback
  36. import tempfile
  37.  
  38. import apt
  39. import apt_pkg
  40. import os
  41. import shutil
  42.  
  43. import pty
  44.  
  45. from DistUpgradeApport import *
  46.  
  47. from DistUpgradeController import DistUpgradeController
  48. from DistUpgradeView import DistUpgradeView, FuzzyTimeToStr, InstallProgress, FetchProgress
  49. from window_main import window_main
  50. from dialog_error import dialog_error
  51. from dialog_changes import dialog_changes
  52. from dialog_conffile import dialog_conffile
  53. from crashdialog import CrashDialog
  54.  
  55. import pty
  56. import select
  57. import gettext
  58. from gettext import gettext as gett
  59.  
  60. def _(str):
  61.     return unicode(gett(str), 'UTF-8')
  62.  
  63. def utf8(str):
  64.   if isinstance(str, unicode):
  65.       return str
  66.   return unicode(str, 'UTF-8')
  67.  
  68. class DumbTerminal(QTextEdit):
  69.     " a very dumb terminal "
  70.     def __init__(self, installProgress, parent_frame):
  71.         " really dumb terminal with simple editing support "
  72.         QTextEdit.__init__(self, "","", parent_frame)
  73.         self.installProgress = installProgress
  74.         self.setFamily("Monospace")
  75.         self.setPointSize(8)
  76.         self.setWordWrap(QTextEdit.NoWrap)
  77.         self.setUndoDepth(0)
  78.         self.setUndoRedoEnabled(False)
  79.         self._block = False
  80.         self.connect(self, SIGNAL("cursorPositionChanged(int,int)"), 
  81.                      self.onCursorPositionChanged)
  82.     def insertWithTermCodes(self, text):
  83.         " support basic terminal codes "
  84.         display_text = ""
  85.         for c in text:
  86.             # \b - backspace
  87.             if c == chr(8):       
  88.                 self.moveCursor(QTextEdit.MoveBackward, True)
  89.                 self.removeSelectedText()
  90.             # \r - is filtered out
  91.             elif c == chr(13):
  92.                 pass
  93.             # \a - bell - ignore for now
  94.             elif c == chr(7):
  95.                 pass
  96.             else:
  97.                 display_text += c
  98.         self.insert(display_text)
  99.     def keyPressEvent(self, ev):
  100.         " send (ascii) key events to the pty "
  101.         # FIXME: use ev.text() here instead and deal with
  102.         # that it sends strange stuff
  103.         if hasattr(self.installProgress,"master_fd"):
  104.             os.write(self.installProgress.master_fd, chr(ev.ascii()))
  105.     def onCursorPositionChanged(self, x, y):
  106.         " helper that ensures that the cursor is always at the end "
  107.         if self._block:
  108.             return
  109.         # block signals so that we do not run into a recursion
  110.         self._block = True
  111.         para = self.paragraphs() - 1
  112.         pos = self.paragraphLength(para)
  113.         self.setCursorPosition(para, pos)
  114.         self._block = False
  115.         
  116.  
  117. class KDECdromProgressAdapter(apt.progress.CdromProgress):
  118.     """ Report the cdrom add progress """
  119.     def __init__(self, parent):
  120.         self.status = parent.window_main.label_status
  121.         self.progressbar = parent.window_main.progressbar_cache
  122.         self.parent = parent
  123.  
  124.     def update(self, text, step):
  125.         """ update is called regularly so that the gui can be redrawn """
  126.         if text:
  127.           self.status.setText(text)
  128.         self.progressbar.setProgress(step/float(self.totalSteps))
  129.         KApplication.kApplication().processEvents()
  130.  
  131.     def askCdromName(self):
  132.         return (False, "")
  133.  
  134.     def changeCdrom(self):
  135.         return False
  136.  
  137. class KDEOpProgress(apt.progress.OpProgress):
  138.   """ methods on the progress bar """
  139.   def __init__(self, progressbar, progressbar_label):
  140.       self.progressbar = progressbar
  141.       self.progressbar_label = progressbar_label
  142.       #self.progressbar.set_pulse_step(0.01)
  143.       #self.progressbar.pulse()
  144.  
  145.   def update(self, percent):
  146.       #if percent > 99:
  147.       #    self.progressbar.set_fraction(1)
  148.       #else:
  149.       #    self.progressbar.pulse()
  150.       #self.progressbar.set_fraction(percent/100.0)
  151.       self.progressbar.setProgress(percent)
  152.       KApplication.kApplication().processEvents()
  153.  
  154.   def done(self):
  155.       self.progressbar_label.setText("")
  156.  
  157. class KDEFetchProgressAdapter(FetchProgress):
  158.     """ methods for updating the progress bar while fetching packages """
  159.     # FIXME: we really should have some sort of "we are at step"
  160.     # xy in the gui
  161.     # FIXME2: we need to thing about mediaCheck here too
  162.     def __init__(self, parent):
  163.         FetchProgress.__init__(self)
  164.         # if this is set to false the download will cancel
  165.         self.status = parent.window_main.label_status
  166.         self.progress = parent.window_main.progressbar_cache
  167.         self.parent = parent
  168.  
  169.     def mediaChange(self, medium, drive):
  170.       msg = _("Please insert '%s' into the drive '%s'") % (medium,drive)
  171.       change = QMessageBox.question(self.parent.window_main, _("Media Change"), msg, QMessageBox.Ok, QMessageBox.Cancel)
  172.       if change == QMessageBox.Ok:
  173.         return True
  174.       return False
  175.  
  176.     def start(self):
  177.         #self.progress.show()
  178.         self.progress.setProgress(0)
  179.         self.status.show()
  180.  
  181.     def stop(self):
  182.         self.parent.window_main.progress_text.setText("  ")
  183.         self.status.setText(_("Fetching is complete"))
  184.  
  185.     def pulse(self):
  186.         """ we don't have a mainloop in this application, we just call processEvents here and elsewhere"""
  187.         # FIXME: move the status_str and progress_str into python-apt
  188.         # (python-apt need i18n first for this)
  189.         FetchProgress.pulse(self)
  190.         self.progress.setProgress(self.percent)
  191.         currentItem = self.currentItems + 1
  192.         if currentItem > self.totalItems:
  193.             currentItem = self.totalItems
  194.  
  195.         if self.currentCPS > 0:
  196.             self.status.setText(_("Fetching file %li of %li at %sb/s") % (currentItem, self.totalItems, apt_pkg.SizeToStr(self.currentCPS)))
  197.             self.parent.window_main.progress_text.setText("<i>" + _("About %s remaining") % unicode(FuzzyTimeToStr(self.eta), 'utf-8') + "</i>")
  198.         else:
  199.             self.status.setText(_("Fetching file %li of %li") % (currentItem, self.totalItems))
  200.             self.parent.window_main.progress_text.setText("  ")
  201.  
  202.         KApplication.kApplication().processEvents()
  203.         return True
  204.  
  205. class KDEInstallProgressAdapter(InstallProgress):
  206.     """methods for updating the progress bar while installing packages"""
  207.     # timeout with no status change when the terminal is expanded
  208.     # automatically
  209.     TIMEOUT_TERMINAL_ACTIVITY = 240
  210.  
  211.     def __init__(self,parent):
  212.         InstallProgress.__init__(self)
  213.         self._cache = None
  214.         self.label_status = parent.window_main.label_status
  215.         self.progress = parent.window_main.progressbar_cache
  216.         self.progress_text = parent.window_main.progress_text
  217.         self.parent = parent
  218.         try:
  219.             self._terminal_log = open("/var/log/dist-upgrade/term.log","w")
  220.         except Exception, e:
  221.             # if something goes wrong (permission denied etc), use stdout
  222.             logging.error("Can not open terminal log: '%s'" % e)
  223.             self._terminal_log = sys.stdout
  224.         # some options for dpkg to make it die less easily
  225.         apt_pkg.Config.Set("DPkg::StopOnError","False")
  226.  
  227.     def startUpdate(self):
  228.         InstallProgress.startUpdate(self)
  229.         self.finished = False
  230.         # FIXME: add support for the timeout
  231.         # of the terminal (to display something useful then)
  232.         # -> longer term, move this code into python-apt 
  233.         self.label_status.setText(_("Applying changes"))
  234.         self.progress.setProgress(0)
  235.         self.progress_text.setText(" ")
  236.         # do a bit of time-keeping
  237.         self.start_time = 0.0
  238.         self.time_ui = 0.0
  239.         self.last_activity = 0.0
  240.         self.parent.window_main.showTerminalButton.setEnabled(True)
  241.  
  242.     def error(self, pkg, errormsg):
  243.         InstallProgress.error(self, pkg, errormsg)
  244.         logging.error("got an error from dpkg for pkg: '%s': '%s'" % (pkg, errormsg))
  245.     # we do not report followup errors from earlier failures
  246.         if gettext.dgettext('dpkg', "dependency problems - leaving unconfigured") in errormsg:
  247.       return False
  248.         summary = _("Could not install '%s'") % pkg
  249.         msg = _("The upgrade will continue but the '%s' package may not "
  250.                 "be in a working state. Please consider submitting a "
  251.                 "bug report about it.") % pkg
  252.         msg = "<big><b>%s</b></big><br />%s" % (summary, msg)
  253.         dialogue = dialog_error(self.parent.window_main)
  254.         dialogue.label_error.setText(utf8(msg))
  255.         if errormsg != None:
  256.             dialogue.textview_error.setText(utf8(errormsg))
  257.             dialogue.textview_error.show()
  258.         else:
  259.             dialogue.textview_error.hide()
  260.         dialogue.connect(dialogue.button_bugreport, SIGNAL("clicked()"), self.parent.reportBug)
  261.         dialogue.exec_loop()
  262.  
  263.     def conffile(self, current, new):
  264.         """ask question in case conffile has been changed by user"""
  265.         logging.debug("got a conffile-prompt from dpkg for file: '%s'" % current)
  266.         start = time.time()
  267.         prim = _("Replace the customized configuration file\n'%s'?") % current
  268.         sec = _("You will lose any changes you have made to this "
  269.                 "configuration file if you choose to replace it with "
  270.                 "a newer version.")
  271.         markup = "<span weight=\"bold\" size=\"larger\">%s </span> \n\n%s" % (prim, sec)
  272.         self.confDialogue = dialog_conffile(self.parent.window_main)
  273.         self.confDialogue.label_conffile.setText(markup)
  274.         self.confDialogue.textview_conffile.hide()
  275.         #FIXME, below to be tested
  276.         #self.confDialogue.resize(self.confDialogue.minimumSizeHint())
  277.         self.confDialogue.connect(self.confDialogue.show_difference_button, SIGNAL("clicked()"), self.showConffile)
  278.  
  279.         # now get the diff
  280.         if os.path.exists("/usr/bin/diff"):
  281.           cmd = ["/usr/bin/diff", "-u", current, new]
  282.           diff = utf8(subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0])
  283.           self.confDialogue.textview_conffile.setText(diff)
  284.         else:
  285.           self.confDialogue.textview_conffile.setText(_("The 'diff' command was not found"))
  286.         result = self.confDialogue.exec_loop()
  287.         self.time_ui += time.time() - start
  288.         # if replace, send this to the terminal
  289.         if result == QDialog.Accepted:
  290.             os.write(self.master_fd, "y\n")
  291.         else:
  292.             os.write(self.master_fd, "n\n")
  293.  
  294.     def showConffile(self):
  295.         if self.confDialogue.textview_conffile.isVisible():
  296.             self.confDialogue.textview_conffile.hide()
  297.             self.confDialogue.show_difference_button.setText(_("Show Difference >>>"))
  298.         else:
  299.             self.confDialogue.textview_conffile.show()
  300.             self.confDialogue.show_difference_button.setText(_("<<< Hide Difference"))
  301.        
  302.  
  303.     def fork(self):
  304.         """pty voodoo"""
  305.         (self.child_pid, self.master_fd)  = pty.fork()
  306.         if self.child_pid == 0:
  307.             os.environ["TERM"] = "dumb"
  308.             if not os.environ.has_key("DEBIAN_FRONTEND"):
  309.                 os.environ["DEBIAN_FRONTEND"] = "kde"
  310.             os.environ["APT_LISTCHANGES_FRONTEND"] = "none"
  311.         logging.debug(" fork pid is: %s" % self.child_pid)
  312.         return self.child_pid
  313.  
  314.     def statusChange(self, pkg, percent, status):
  315.         """update progress bar and label"""
  316.         # start the timer when the first package changes its status
  317.         if self.start_time == 0.0:
  318.           #print "setting start time to %s" % self.start_time
  319.           self.start_time = time.time()
  320.         self.progress.setProgress(self.percent)
  321.         self.label_status.setText(unicode(status.strip(), 'UTF-8'))
  322.         # start showing when we gathered some data
  323.         if percent > 1.0:
  324.           self.last_activity = time.time()
  325.           self.activity_timeout_reported = False
  326.           delta = self.last_activity - self.start_time
  327.           # time wasted in conffile questions (or other ui activity)
  328.           delta -= self.time_ui
  329.           time_per_percent = (float(delta)/percent)
  330.           eta = (100.0 - self.percent) * time_per_percent
  331.           # only show if we have some sensible data (60sec < eta < 2days)
  332.           if eta > 61.0 and eta < (60*60*24*2):
  333.             self.progress_text.setText(_("About %s remaining") % FuzzyTimeToStr(eta))
  334.           else:
  335.             self.progress_text.setText(" ")
  336.  
  337.     def finishUpdate(self):
  338.         self.label_status.setText("")
  339.  
  340.     def updateInterface(self):
  341.         """
  342.         no mainloop in this application, just call processEvents lots here
  343.         it's also important to sleep for a minimum amount of time
  344.         """
  345.         # log the output of dpkg (on the master_fd) to the terminal log
  346.         while True:
  347.             try:
  348.                 (rlist, wlist, xlist) = select.select([self.master_fd],[],[], 0)
  349.                 if len(rlist) > 0:
  350.                     line = os.read(self.master_fd, 255)
  351.                     self._terminal_log.write(line)
  352.                     self.parent.terminal_text.insertWithTermCodes(utf8(line))
  353.                 else:
  354.                     break
  355.             except Exception, e:
  356.                 print e
  357.                 logging.debug("error reading from self.master_fd '%s'" % e)
  358.                 break
  359.  
  360.         # now update the GUI
  361.         try:
  362.           InstallProgress.updateInterface(self)
  363.         except ValueError, e:
  364.           logging.error("got ValueError from InstallProgress.updateInterface. Line was '%s' (%s)" % (self.read, e))
  365.           # reset self.read so that it can continue reading and does not loop
  366.           self.read = ""
  367.         # check about terminal activity
  368.         if self.last_activity > 0 and \
  369.            (self.last_activity + self.TIMEOUT_TERMINAL_ACTIVITY) < time.time():
  370.           if not self.activity_timeout_reported:
  371.             #FIXME bug 95465, I can't recreate this, so here's a hacky fix
  372.             try:
  373.                 logging.warning("no activity on terminal for %s seconds (%s)" % (self.TIMEOUT_TERMINAL_ACTIVITY, self.label_status.text()))
  374.             except UnicodeEncodeError:
  375.                 logging.warning("no activity on terminal for %s seconds" % (self.TIMEOUT_TERMINAL_ACTIVITY))
  376.             self.activity_timeout_reported = True
  377.           self.parent.window_main.konsole_frame.show()
  378.         KApplication.kApplication().processEvents()
  379.         time.sleep(0.02)
  380.  
  381.     def waitChild(self):
  382.         while True:
  383.             self.updateInterface()
  384.             (pid, res) = os.waitpid(self.child_pid,os.WNOHANG)
  385.             if pid == self.child_pid:
  386.                 break
  387.         return os.WEXITSTATUS(res)
  388.  
  389. # inherit from the class created in window_main.ui
  390. # to add the handler for closing the window
  391. class UpgraderMainWindow(window_main):
  392.  
  393.     def setParent(self, parentRef):
  394.         self.parent = parentRef
  395.  
  396.     def closeEvent(self, event):
  397.         close = self.parent.on_window_main_delete_event()
  398.         if close:
  399.           event.accept()
  400.  
  401. class DistUpgradeViewKDE(DistUpgradeView):
  402.     """KDE frontend of the distUpgrade tool"""
  403.     def __init__(self, datadir=None, logdir=None):
  404.         if not datadir:
  405.           localedir=os.path.join(os.getcwd(),"mo")
  406.         else:
  407.           localedir="/usr/share/locale/update-manager"
  408.  
  409.         # FIXME: i18n must be somewhere relative do this dir
  410.         try:
  411.           gettext.bindtextdomain("update-manager", localedir)
  412.           gettext.textdomain("update-manager")
  413.         except Exception, e:
  414.           logging.warning("Error setting locales (%s)" % e)
  415.  
  416.         about=KAboutData("adept_manager","Upgrader","0.1","Dist Upgrade Tool for Kubuntu",KAboutData.License_GPL,"(c) 2007 Canonical Ltd",
  417.         "http://wiki.kubuntu.org/KubuntuUpdateManager", "jriddell@ubuntu.com")
  418.         about.addAuthor("Jonathan Riddell", None,"jriddell@ubuntu.com")
  419.         about.addAuthor("Michael Vogt", None,"michael.vogt@ubuntu.com")
  420.         KCmdLineArgs.init(["./dist-upgrade.py"],about)
  421.  
  422.         self.app = KApplication()
  423.  
  424.         self.window_main = UpgraderMainWindow()
  425.         self.window_main.setParent(self)
  426.         self.window_main.show()
  427.  
  428.         self.prev_step = 0 # keep a record of the latest step
  429.  
  430.         self._opCacheProgress = KDEOpProgress(self.window_main.progressbar_cache, self.window_main.progress_text)
  431.         self._fetchProgress = KDEFetchProgressAdapter(self)
  432.         self._cdromProgress = KDECdromProgressAdapter(self)
  433.  
  434.         self._installProgress = KDEInstallProgressAdapter(self)
  435.  
  436.         # reasonable fault handler
  437.         sys.excepthook = self._handleException
  438.  
  439.         ###self.window_main.showTerminalButton.setEnabled(False)
  440.         self.app.connect(self.window_main.showTerminalButton, SIGNAL("clicked()"), self.showTerminal)
  441.  
  442.         #kdesu requires us to copy the xauthority file before it removes it when Adept is killed
  443.         copyXauth = tempfile.mktemp("", "adept")
  444.         if 'XAUTHORITY' in os.environ and os.environ['XAUTHORITY'] != copyXauth:
  445.             shutil.copy(os.environ['XAUTHORITY'], copyXauth)
  446.             os.environ["XAUTHORITY"] = copyXauth
  447.  
  448.         # Note that with kdesudo this needs --nonewdcop
  449.         ## create a new DCOP-Client:
  450.         #client = DCOPClient()
  451.         ## connect the client to the local DCOP-server:
  452.         #client.attach()
  453.  
  454.         #for qcstring_app in client.registeredApplications():
  455.         #    app = str(qcstring_app)
  456.         #    if app.startswith("adept"): 
  457.         #        adept = DCOPApp(qcstring_app, client)
  458.         #        adeptInterface = adept.object("MainApplication-Interface")
  459.         #        adeptInterface.quit()
  460.  
  461.         # This works just as well
  462.         subprocess.call(["killall", "adept_manager"])
  463.         subprocess.call(["killall", "adept_updater"])
  464.  
  465.         # init gettext
  466.         gettext.bindtextdomain("update-manager",localedir)
  467.         gettext.textdomain("update-manager")
  468.         self.translate_widget_children()
  469.         self.window_main.label_title.setText(self.window_main.label_title.text().replace("Ubuntu", "Kubuntu"))
  470.  
  471.         # setup terminal text in hidden by default spot
  472.         self.window_main.konsole_frame.hide()
  473.         self.konsole_frame_layout = QHBoxLayout(self.window_main.konsole_frame)
  474.         self.window_main.konsole_frame.setMinimumSize(600, 400)
  475.         self.terminal_text = DumbTerminal(self._installProgress, 
  476.                                           self.window_main.konsole_frame)
  477.         self.konsole_frame_layout.addWidget(self.terminal_text)
  478.         self.terminal_text.show()
  479.         
  480.         # for some reason we need to start the main loop to get everything displayed
  481.         # this app mostly works with processEvents but run main loop briefly to keep it happily displaying all widgets
  482.         QTimer.singleShot(10, self.exitMainLoop)
  483.         self.app.exec_loop()
  484.         
  485.     def exitMainLoop(self):
  486.         self.app.exit()
  487.  
  488.     def translate_widget_children(self, parentWidget=None):
  489.         if parentWidget == None:
  490.             parentWidget = self.window_main
  491.  
  492.         if parentWidget.children() != None:
  493.             for widget in parentWidget.children():
  494.                 self.translate_widget(widget)
  495.                 self.translate_widget_children(widget)
  496.  
  497.     def translate_widget(self, widget):
  498.         if isinstance(widget, QLabel) or isinstance(widget, QPushButton):
  499.             if str(widget.text()) != "":
  500.                 widget.setText(_(str(widget.text())))
  501.  
  502.     def _handleException(self, exctype, excvalue, exctb):
  503.         """Crash handler."""
  504.  
  505.         if (issubclass(exctype, KeyboardInterrupt) or
  506.             issubclass(exctype, SystemExit)):
  507.             return
  508.  
  509.         # we handle the exception here, hand it to apport and run the
  510.         # apport gui manually after it because we kill u-m during the upgrade
  511.         # to prevent it from popping up for reboot notifications or FF restart
  512.         # notifications or somesuch
  513.         lines = traceback.format_exception(exctype, excvalue, exctb)
  514.         logging.error("not handled exception in KDE frontend:\n%s" % "\n".join(lines))
  515.         # we can't be sure that apport will run in the middle of a upgrade
  516.         # so we still show a error message here
  517.         apport_crash(exctype, excvalue, exctb)
  518.         if not run_apport():
  519.             tbtext = ''.join(traceback.format_exception(exctype, excvalue, exctb))
  520.             dialog = CrashDialog(self.window_main)
  521.             dialog.connect(dialog.beastie_url, SIGNAL("leftClickedURL(const QString&)"), self.openURL)
  522.             dialog.crash_detail.setText(tbtext)
  523.             dialog.exec_loop()
  524.         sys.exit(1)
  525.  
  526.     def openURL(self, url):
  527.         """start konqueror"""
  528.         #need to run this else kdesu can't run Konqueror
  529.         #subprocess.call(['su', 'ubuntu', 'xhost', '+localhost'])
  530.         KRun.runURL(KURL(url), "text/html")
  531.  
  532.     def reportBug(self):
  533.         """start konqueror"""
  534.         #need to run this else kdesu can't run Konqueror
  535.         #subprocess.call(['su', 'ubuntu', 'xhost', '+localhost'])
  536.         KRun.runURL(KURL("https://launchpad.net/distros/ubuntu/+source/update-manager/+filebug"), "text/html")
  537.  
  538.     def showTerminal(self):
  539.         if self.window_main.konsole_frame.isVisible():
  540.             self.window_main.konsole_frame.hide()
  541.             self.window_main.showTerminalButton.setText(_("Show Terminal >>>"))
  542.         else:
  543.             self.window_main.konsole_frame.show()
  544.             self.window_main.showTerminalButton.setText(_("<<< Hide Terminal"))
  545.         self.window_main.resize(self.window_main.sizeHint())
  546.  
  547.     def getFetchProgress(self):
  548.         return self._fetchProgress
  549.  
  550.     def getInstallProgress(self, cache):
  551.         self._installProgress._cache = cache
  552.         return self._installProgress
  553.  
  554.     def getOpCacheProgress(self):
  555.         return self._opCacheProgress
  556.  
  557.     def getCdromProgress(self):
  558.         return self._cdromProgress
  559.  
  560.     def updateStatus(self, msg):
  561.         #self.window_main.label_status.setText("%s" % msg)
  562.         print "updateStatus: " + msg
  563.         self.window_main.label_status.setText(unicode(msg, 'UTF-8'))
  564.  
  565.     def hideStep(self, step):
  566.         image = getattr(self.window_main,"image_step%i" % step)
  567.         label = getattr(self.window_main,"label_step%i" % step)
  568.         image.hide()
  569.         label.hide()
  570.  
  571.     def abort(self):
  572.         step = self.prev_step
  573.         if step > 0:
  574.             image = getattr(self.window_main,"image_step%i" % step)
  575.             iconLoader = KIconLoader()
  576.             cancelIcon = iconLoader.loadIcon("cancel", KIcon.Small)
  577.             image.setPixmap(cancelIcon)
  578.             image.show()
  579.  
  580.     def setStep(self, step):
  581.         iconLoader = KIconLoader()
  582.         if self.prev_step:
  583.             image = getattr(self.window_main,"image_step%i" % self.prev_step)
  584.             label = getattr(self.window_main,"label_step%i" % self.prev_step)
  585.             okIcon = iconLoader.loadIcon("ok", KIcon.Small)
  586.             image.setPixmap(okIcon)
  587.             image.show()
  588.             ##arrow.hide()
  589.         self.prev_step = step
  590.         # show the an arrow for the current step and make the label bold
  591.         image = getattr(self.window_main,"image_step%i" % step)
  592.         label = getattr(self.window_main,"label_step%i" % step)
  593.         arrowIcon = iconLoader.loadIcon("1rightarrow", KIcon.Small)
  594.         image.setPixmap(arrowIcon)
  595.         image.show()
  596.         label.setText("<b>" + label.text() + "</b>")
  597.  
  598.     def information(self, summary, msg, extended_msg=None):
  599.         msg = "<big><b>%s</b></big><br />%s" % (summary,msg)
  600.  
  601.         dialogue = dialog_error(self.window_main)
  602.         dialogue.label_error.setText(utf8(msg))
  603.         if extended_msg != None:
  604.             dialogue.textview_error.setText(utf8(extended_msg))
  605.             dialogue.textview_error.show()
  606.         else:
  607.             dialogue.textview_error.hide()
  608.         dialogue.button_bugreport.hide()
  609.         dialogue.setCaption("Information")
  610.         iconLoader = KIconLoader()
  611.         messageIcon = iconLoader.loadIcon("messagebox_info", KIcon.Panel)
  612.         dialogue.image.setPixmap(messageIcon)
  613.         dialogue.exec_loop()
  614.  
  615.     def error(self, summary, msg, extended_msg=None):
  616.         msg="<big><b>%s</b></big><br />%s" % (summary, msg)
  617.  
  618.         dialogue = dialog_error(self.window_main)
  619.         dialogue.label_error.setText(utf8(msg))
  620.         if extended_msg != None:
  621.             dialogue.textview_error.setText(utf8(extended_msg))
  622.             dialogue.textview_error.show()
  623.         else:
  624.             dialogue.textview_error.hide()
  625.         dialogue.button_close.show()
  626.         self.app.connect(dialogue.button_bugreport, SIGNAL("clicked()"), self.reportBug)
  627.         dialogue.exec_loop()
  628.  
  629.         return False
  630.  
  631.     def confirmChanges(self, summary, changes, downloadSize, 
  632.                        actions=None, removal_bold=True):
  633.         """show the changes dialogue"""
  634.         # FIXME: add a whitelist here for packages that we expect to be
  635.         # removed (how to calc this automatically?)
  636.  
  637.         DistUpgradeView.confirmChanges(self, summary, changes, downloadSize)
  638.         msg = unicode(self.confirmChangesMessage, 'UTF-8')
  639.         self.changesDialogue = dialog_changes(self.window_main)
  640.         self.changesDialogue.treeview_details.hide()
  641.         self.changesDialogue.connect(self.changesDialogue.show_details_button, SIGNAL("clicked()"), self.showChangesDialogueDetails)
  642.         self.translate_widget_children(self.changesDialogue)
  643.         self.changesDialogue.show_details_button.setText(_("Details") + " >>>")
  644.         self.changesDialogue.resize(self.changesDialogue.sizeHint())
  645.  
  646.         if actions != None:
  647.             cancel = actions[0].replace("_", "")
  648.             self.changesDialogue.button_cancel_changes.setText(cancel)
  649.             confirm = actions[1].replace("_", "")
  650.             self.changesDialogue.button_confirm_changes.setText(confirm)
  651.  
  652.         summaryText = unicode("<big><b>%s</b></big>" % summary, 'UTF-8')
  653.         self.changesDialogue.label_summary.setText(summaryText)
  654.         self.changesDialogue.label_changes.setText(msg)
  655.         # fill in the details
  656.         self.changesDialogue.treeview_details.clear()
  657.         self.changesDialogue.treeview_details.setColumnText(0, "Packages")
  658.         for rm in self.toRemove:
  659.             self.changesDialogue.treeview_details.insertItem( QListViewItem(self.changesDialogue.treeview_details, _("Remove %s") % rm) )
  660.         for inst in self.toInstall:
  661.             self.changesDialogue.treeview_details.insertItem( QListViewItem(self.changesDialogue.treeview_details, _("Install %s") % inst) )
  662.         for up in self.toUpgrade:
  663.             self.changesDialogue.treeview_details.insertItem( QListViewItem(self.changesDialogue.treeview_details, _("Upgrade %s") % up) )
  664.         res = self.changesDialogue.exec_loop()
  665.         if res == QDialog.Accepted:
  666.             return True
  667.         return False
  668.  
  669.     def showChangesDialogueDetails(self):
  670.         if self.changesDialogue.treeview_details.isVisible():
  671.             self.changesDialogue.treeview_details.hide()
  672.             self.changesDialogue.show_details_button.setText(_("Details") + " >>>")
  673.         else:
  674.             self.changesDialogue.treeview_details.show()
  675.             self.changesDialogue.show_details_button.setText("<<< " + _("Details"))
  676.         self.changesDialogue.resize(self.changesDialogue.sizeHint())
  677.  
  678.     def askYesNoQuestion(self, summary, msg, default='No'):
  679.         restart = QMessageBox.question(self.window_main, unicode(summary, 'UTF-8'), unicode("<font>") + unicode(msg, 'UTF-8'), QMessageBox.Yes, QMessageBox.No)
  680.         if restart == QMessageBox.Yes:
  681.             return True
  682.         return False
  683.  
  684.     def processEvents(self):
  685.         KApplication.kApplication().processEvents()
  686.  
  687.     def on_window_main_delete_event(self):
  688.         text = _("""<b><big>Cancel the running upgrade?</big></b>
  689.  
  690. The system could be in an unusable state if you cancel the upgrade. You are strongly advised to resume the upgrade.""")
  691.         text = text.replace("\n", "<br />")
  692.         cancel = QMessageBox.warning(self.window_main, _("Cancel Upgrade?"), text, QMessageBox.Yes, QMessageBox.No)
  693.         if cancel == QMessageBox.Yes:
  694.             return True
  695.         return False
  696.  
  697.  
  698.  
  699. if __name__ == "__main__":
  700.  
  701.   view = DistUpgradeViewKDE()
  702.  
  703.   cache = apt.Cache()
  704.   for pkg in sys.argv[1:]:
  705.     if cache[pkg].isInstalled and not cache[pkg].isUpgradable: 
  706.       cache[pkg].markDelete(purge=True)
  707.     else:
  708.       cache[pkg].markInstall()
  709.   cache.commit(view._fetchProgress,view._installProgress)
  710.  
  711.   # keep the window open
  712.   while True:
  713.       KApplication.kApplication().processEvents()
  714.